\documentclass[a4paper,12pt]{report}
\usepackage[portuges]{babel}
\usepackage[utf8]{inputenc}
\usepackage{ifthen}
\selectlanguage{portuges}
\usepackage[pdftex]{graphicx}
\newcommand{\HRule}{\rule{\linewidth}{0.5mm}}
\usepackage{multicol}
\usepackage{thumbpdf}
\usepackage{alltt}
\usepackage[pdftex,
        colorlinks=true,
        linkcolor=rltred,       % \ref{...} and \pageref{...}
        urlcolor=rltblue,       % \href{...}{...} external (URL)
        filecolor=rltgreen,     % \href{...} local file
        pdftitle={LCOM Hangman},
        pdfauthor={Ângela Igreja & Ricardo Silva},
        pdfsubject={LCOM},
        pdfkeywords={LCOM,FEUP,Hangman},
        pdfproducer={pdfLaTeX},
        pagebackref,
        pdfpagemode=None,
        bookmarksopen=true]{hyperref}
\usepackage{listings,babel}
\lstset{breaklines=true,basicstyle=\ttfamily}


\usepackage{color}
\definecolor{rltred}{rgb}{0.75,0,0}
\definecolor{rltgreen}{rgb}{0,0.5,0}
\definecolor{rltblue}{rgb}{0,0,0.75}

\usepackage{fancyhdr}
\pagestyle{fancy}
\usepackage{fancyvrb}
\usepackage{relsize}

\chead{}
\rhead{}

%-----------------------------------------------------------------------------------------------------------------------------------------------------

\begin{document}
\input{./title.tex}


\newpage
\tableofcontents

\setcounter{chapter}{1}
\chapter*{1. Resumo}
\addcontentsline{toc}{chapter}{1. Resumo}


\indent
\hspace{7 mm}O projecto desenvolvido teve como principais objectivos conhecer e utilizar a interface de hardware dos periféricos habituais de um computador, melhorar o uso da linguagem de programação C de modo estruturado, melhorar as capacidades de desenvolver software de baixo nível e embebido para a plataforma PC, assim como ganhar familiaridade com algumas ferramentas de desenvolvimento do referido software. 

Relativamente aos recursos de hardware do computador utilizados, este projecto permitiu a integração de modo harmonioso todos os periféricos estudados ao longo do semestre na unidade curricular Laboratório de Computadores, foi utilizada a placa gráfica no modo texto e no modo gráfico, o contador, o altifalante, o teclado, o rato, o RTC (Real Time Controller) e o Porto Série.

A placa gráfica foi utilizada no modo gráfico como interface do jogo, o teclado e o rato são usados no jogo para aceder aos menus, através de interrupções com recurso a rotinas escritas em assembly.

A utilização do RTC permite uma contagem do tempo de jogo decorrido e a disponibilização ao utilizador da hora e data do sistema.

O Porto Série foi usado para estabeler a ligação entre dois jogadores em Pc's diferentes.

Finalmente, foi utilizado o altifalante na incorporação de som no decorrer do jogo.

O programa têm tambem suporte em ambiente embedded. 

A nível de software, foi utilizado o compilador DJGPP, o assemblador NASM, a makefile como ferramenta de gestão de dependências entre vários módulos, o SVN para a gestão das versões do projecto, o Doxygen para gerar a documentação, o Dosbox para efeitos de teste e o GDB para a resolução de problemas. 

%-----------------------------------------------------------------------------------------------------------------------------------------------------
\setcounter{chapter}{2}
\chapter*{2. Descrição do Programa}
\addcontentsline{toc}{chapter}{2. Descrição do Programa}

O projecto desenvolvido, designado de “O Enforcado”, foi baseado no jogo tradicional com o mesmo nome.

De início, é apresentado ao jogador um menu onde poderá escolher uma de 4 opções: Play, Scores, Manual ou Exit. Se o jogador escolher a opção “Play”, depois poderá escolher uma de 4 opções: One Player, Two Players – Server, Two Players – Client ou Go Back.

Interface:
Os elementos presentes na interface durante o decorrer do jogo são:
\begin{itemize}
\item Forca;
\item Enforcado (quando jogador erra);
\item Traços para completar palavra;
\item Dica;
\item Alfabeto a indicar letras já usadas;
\item Letra apostada na última vez;
\item Hora actual;
\item Data actual;
\item Tempo decorrido desde o início do jogo;
\item Pontuação;
\item Nome do Jogador.
\end{itemize}

Os elementos referidos encontram-se dispostos da seguinte maneira:
\begin{itemize}
\item Abecedário encontram-se na parte inferior do ecrã;
\item Informação sobre tempo, jogador, pontuação encontram-se na parte direita do ecrã;
\item Dica encontra-se na posição central do ecrã, tendo por baixo a última letra usada, e por baixo desta, do lado esquerdo, os traços com a palavra-chave e, do lado direito, a forca.
\end{itemize}

Regras de jogo:
\begin{itemize}
\item O jogador tem que acertar a palavra-chave (gerada aleatoriamente pelo computador no modo “One Player” ou pelo Servidor no modo “Two Players – Client”), sendo que no máximo só pode errar 6 vezes. No final, se vencer, é-lhe atribuída uma pontuação.
\item No modo “Two Players – Server”, o jogador tem que fornecer palavra-chave e dica ao outro e esperar pelo resultado. Se o outro jogador vencer o jogo, recebe a pontuação correspondente.
\item A pontuação depende de letras da palavra-chave e do número de erros. Quanto mais letras tiver a palavra-chave e menos erros cometer, maior será a pontuação.
\end{itemize}

%-----------------------------------------------------------------------------------------------------------------------------------------------------
\setcounter{chapter}{3}
\chapter*{3. Implementação}
\addcontentsline{toc}{chapter}{3. Implementação}
\section{Arquitectura do Programa}

Módulos e breve descrição:

\begin{itemize}
\item Main – responsável pela instalação/desinstalação das interrupções, entrada/saída do modo gráfico e chamada do módulo de Menu;
\item Jogo – módulo mais importante do sistema, é responsável por criar todo o ambiente de jogo, gerir todos os momentos assim como controlar todas as acções efectuados pelo(s) jogador(es);
\item Menu – módulo responsável por inicialização dos menus, selecções das opções pretendidas e de criação de sub-menus (menu de Jogo). È responsável por chamar o módulo de Jogo.
\item Jogador – módulo responsável por criar/destruir um Jogador.
\item Interrupções – contém as funções de instalação/desinstalação de interrupções escritas na linguagem Assembly ou C e função de habilitar/desabilitar de PIC’s;
\item Mouse – contém as funções para desenho do e de verificação para efectuar clique em opções do menu.
\item Real Time Controller (RTC) – contém todas as funções necessárias à utilização do RTC. Inclui funções de escrita/leitura do RTC;
\item Controlador de Rato e Teclado – contém as funções que activam/desactivam as interrupções provenientes do teclado e do rato e de controlo da actualização das coordenadas do rato;
\item Music – contém as funções necessárias ao uso do speaker no programa, mais concretamente, ligar/desligar esse speaker e tocar notas/músicas;
\item Timer – contém as funções que programar os timers(0, 1, 2);
\item Video – contém as funções necessárias ao uso da placa gráfica do computador em modo gráfico. Inclui as funções de entrada/saída do modo gráfico, de desenho e obtenção de propriedades de pixéis, impressão de caracteres no ecrã e função que “limpa” o ecrã com uma determinada cor na sua totalidade;
\item Sprite – contém funções para ler ficheiro xpm, criar e desenhar sprite.
\item Embed – assim como o módulo “Video”, contém as funções necessárias ao uso da placa gráfica do computador em modo gráfico, com as devidas alterações para se poder usar estas em ambiente embebido;
\item Porta Série – contém as funções necessárias ao uso da comunicação em série entre dois PC’s. Inclui as funções de inicializar/limpar a UART, definição/obtenção dos registos da UART e que permitem enviar/receber caracteres ou strings enviadas/recebidas pela UART;
\end{itemize}

\newpage
Diagrama UML:

\begin{figure}[ht]
\begin{center}
\includegraphics[width=16cm]{./umllcom.png}
\end{center}
\caption[UML]{UML}
\end{figure}

\newpage
\section{Funcionalidades}

Funcionalidades implementadas:
\begin{itemize}
\item Funcionalidades implementadas:
\item Controlo de interrupções do teclado, do rato, do contador, e do RTC;
\item Escrita de texto em modo gráfico;
\item Possibilidade de jogo em modo normal e em ambiente embebido;
\item Possibilidade de jogo com dois jogadores através da comunicação por portas de série;
\end{itemize}

Funcionalidades não especificadas mas implementadas:
\begin{itemize}
\item Possibilidade de jogo em ambiente embebido;
\end{itemize}

Limitações do programa:
\begin{itemize}
\item No caso em que o jogador-servidor insere uma palavra-chave que contenha hífens, esta não funcionará;Controlo de interrupções do teclado, do rato, do contador, e do RTC;
\item Escrita de texto em modo gráfico;
\item Possibilidade de jogo em modo normal e em ambiente embebido;
\item Possibilidade de jogo com dois jogadores através da comunicação por portas de série;
\end{itemize}

Funcionalidades não especificadas mas implementadas:
\begin{itemize}
\item Possibilidade de jogo em ambiente embebido;
\end{itemize}

Limitações do programa:
\begin{itemize}
\item No caso em que o jogador-servidor insere uma palavra-chave que contenha hífens, esta não funcionará;
\end{itemize}

\section{Detalhes Relevantes da Implementação}
Criaram-se vários módulos, onde em cada um são tratadas as funcionalidades específicas, sendo as chamadas a estas todas reunidas no main.

Ao longo do jogo, todo o tratamento de interrupções do teclado é feito pela rotina de interrupção kbc\_isr, escrita em Assembly. Da mesma forma, todo o tratamento de interrupções do contador é feito pela rotina de interrupção temp, também escrita em Assembly. A contagem do tempo de jogo é feita com 
recurso a uma rotina de interrupção do RTC escrita na linguagem C.

Foi criado um gestor de jogo, que além de possuir toda a informação do jogo, controla este.

O programa permite ao jogador o modo de jogar sozinho ou acompanhado, através da porta de série. No modo “One Player” a escolha da dica/palavra-chave é completamente aleatória, sendo que o sistema vai buscá-las a um dicionário criado no gestor de jogo. Relativamente à pontuação, esta é calculada através de uma fórmula pré-definida $(\ (\ 6 - num\-errors\ )\ *\ 5\ *\ num\-letters\ )$.

Para utilização correcta do porto série, utilizou-se a estratégia de ter um carácter de controlo, de forma a evitar perda de informação e lixo nas portas. 

O rato foi usado na utilização da interface gráfica permitindo seleccionar as opções tal como no teclado. Para isto utilizou-se uma rotina mouse\_isr em assembly que retira os dados do kbc e funções em C para actualizar as coordenadas e desenhar o rato.

De forma a conseguir ter o programa a compilar e funcionar em modo normal e em ambiente embebido, foi definido, na makefile, compilação com condições, de forma a ser possível distinguir quando é para compilar normalmente ou compilar em ambiente embebido. Ao longo do projecto existem vários ‘ifndef EMBED’ de forma ao programa utilizar as funções correctas quando tem que trabalhar em modo embebido ou modo normal. Desta forma, evita-se erros de compilação e certifica-se que o programa trabalha nos dois modos.
\newpage
\section{Instruções de compilação e utilização}

Para compilar o programa para Ambiente Windows98 basta executar o comando "make", caso se pretenda compilar o programa para Ambiente Embebido executar o comando "make B=embed".
    
Para limpar o ficheiros com extensão .o, executáveis e bibliotecas criados após a compilação do programa basta executar o comando "make clean".
    
Target's principais do makefile são:
\begin{itemize}
\item make all;
\item make clean;
\item make B=embed;
\end{itemize}
    
Para invocar o programa basta chamar o executável hangman, existindo um opção de aceitar um argumento na linha de comandos para especificar qual a UART a utilizar na comunicação série do computador, por default é usada a UART do porto série COM1. 

Não são necessários ficheiros ou directórios adicionais.
    
Funcionamento do programa:

O programa começa por exibir um menu com 4 opções (Play Game, High Scores, Help, Exit). Para se movimentar nas opções do menu, o jogador utiliza as teclas UP (seta para cima) e DOWN (seta para baixo), a selecção da opção escolhida é feita através do clique na techa ENTER.
 
A opção Play Game apresenta ao jogador um submenu com 4 opções (One Player, Two Players - Server, Two Players - Client, Go back), dependendo da opção escolhida pelo jogador estamos perante diferentes modos de funcionamento do programa. A opçao One Player permite jogar um jogador sozinho num computador. As opções Two Players - Server e Two Players - Client permite establecer um jogo entre dois jogadores em computadores diferentes, em que os dois tem de escolher opções distintas, ou seja um tem de dizer a palavra e o outro tem de tentar adivinhar esta palavra.

No decorrer do jogo o jogador utiliza o teclado para inserir as letras desejadas para a palavra. 
    
Teclas Especiais:
\begin{itemize}
\item Seta para cima : possibilidade de movimentação na vertical e para cima do cursor no menu;
\item Seta para baixo : possibilidade de movimentação na vertical e para baixo do cursor no menu;
\item Enter : escolha de opção no menu; 
\end{itemize}


%-----------------------------------------------------------------------------------------------------------------------------------------------------

\chapter*{4. Conclusões} 
\addcontentsline{toc}{chapter}{4. Conclusões}

\indent
\hspace{7 mm}Este projecto serviu para aprofundar e aplicar os conhecimentos adquiridos nos sete trabalhos práticos, mais o ambiente embebido, que se fizeram durante o semestre na unidade curricular Laborátorio de Computadores. O trabalho permitiu uma boa aprendizagem sobre como interligar todas componentes do trabalho, componentes estas que haviam sido tratadas separadamente. Permitiu também entender, de uma forma mais prática, qual o uso de todos os periféricos usados na disciplina.

Ao longo do desenvolvimento do trabalho, todas as dificuldades encontradas, de salientar os erros de compilação desconhecidos relativos ao ambiente embebido e os problemas em ligar dois computadores através do porto série, foram sempre ultrapassadas, quer graças às explicações das aulas teóricas, quer graças ao apoio prestado pelo professor e pelo monitor nas aulas práticas, quer graças a alguma pesquisa intensiva na internet. Muito obrigado a todos.

Caso houvesse mais tempo para o projecto, alguns melhoramentos poderiam ser feitos ao programa, tais como:
\begin{itemize}
\item Inserção de animações (por exemplo, uma animação para o enforcado);
\item Possibilidade de escolher uma música ambiente;
\item Troca de mensagens entre os dois jogadores no modo “Two Players”;
\end{itemize}

O grupo cumpriu, com sucesso, todos os objectivos propostos para cada aula. Apesar de sempre se poder melhorar, os dois elementos do grupo fizeram de tudo para conseguir, no final, o melhor projecto possível.

%-----------------------------------------------------------------------------------------------------------------------------------------------------

\appendix
\chapter{Documentação do Código}
\chaptermark{Appendix}
\markboth{Appendix}{Appendix}

Main (main.c) - responsável pela instalação/desinstalação das interrupções, entrada/saída do modo gráfico e chamada do módulo de Menu.
\begin{itemize}
\item void setup\_ints() - função que instala as interrupções no modo de ambiente embebido;
\item void leave() - função responsável por abandonar o programa no modo de ambiente embebido;
\item void setup\_peripherals() - função que instala as interrupções relativas ao timer;
\item void main(long vmem) - função que inicia o programa no modo de ambiente embebido;
\item int main(int argc, char * argv[]) - função que inicia o programa no modo normal;
\end{itemize}

Jogo (game.c) - módulo mais importante do sistema, é responsável por criar todo o ambiente de jogo, gerir todos os momentos assim como controlar todas as acções efectuados pelo(s) jogador(es);
\begin{itemize}
\item SecretWord generate\_string(SecretWord * dictionary) - função que gera uma palavra-chave e respective dica aleatoriamente;
\item int find\_letter(char * word, char letter, char * letter\_found) - função que verifica se a letra está ou não na palavra-chave;
\item void update\_word(int x\_pos, int y\_pos, int fore\_color, int back\_color, int char\_scale, char * video\_base, char * table, char * word, char letter) - função que actualize a palavra-chave quando o jogador acerta uma letra;
\item void draw\_traces(int x\_pos, int y\_pos, int color, char * base, char * word) - função que desenha os traços correspondents ao número de letras da palavra-chave;
\item void draw\_gallow(int x\_pos, int y\_pos, int color, char * base) - função que desenha a forca;
\item void draw\_Hangman(int x\_pos, int y\_pos, int color, char * base, int num\_errors) - função que desenha a parte do enforcado relativamente ao número do erro (num\_erros = 1 -> cabeca | num\_erros = 2 -> tronco ...);
\item int calculate\_score(int num\_errors, int num\_letters) - função que calcula a pontuação do jogador no jogo;
\item void update\_best\_scores(Player ** best\_players, Player * player) - função que actualiza o array de melhores pontuações;
\item void print\_best\_scores(Player ** best\_players, char * video\_base, char * table) - função que imprime o array de melhores pontuações;
\item void drawAlphabet(char * video\_base, char * table) - função que desenha o alfabeto;
\item void updateAlphabet(char * letters\_used, char * video\_base, char * table) - função que actualize o alfabeto;
\item void play\_single(char * video\_base, char * table, Player ** best\_players) - função de motor de jogo para um jogador;
\item void play\_client(Word base, char * video\_base, char * table, Player ** best\_players) - função de motor de jogo para dois jogadores - jogador cliente;
\item void play\_server(Word base, char * video\_base, char * table, Player ** best\_players) - função de motor de jogo para dois jogadores - jogador servidor;
\item Bool sync\_server(Word base, char * video\_base, char * table) - função de sincronização do jogador servidor (modo dois jogadores);
\item Bool sync\_client(Word base, char * video\_base, char * table) - função de sincronização do jogador cliente (modo dois jogadores);
\item void showManual(char * video\_base, char * table) - função que mostra o manual;
\end{itemize}

Menu (menu.c) - módulo responsável por inicialização dos menus, selecções das opções pretendidas e de criação de sub-menus (menu de Jogo). È responsável por chamar o módulo de Jogo;
\begin{itemize}
\item void initMenu(char options[][32], Menu * menu, int num\_options) - Construtor de menu;
\item void printMenu(Menu * menu, char * video\_base, char * table) - função que imprime o menu;
\item Bool updateMenu(int sc, Menu * menu) - função que actualize o menu;
\item int selectedOption(Menu * menu) - função que devolve o índice correspondente à opção do menu seleccionada;
\item void sub\_menu(Menu * menu, char * video\_base, char * table, Word base, Player ** best\_players, int mouse\_sup) - função de novo menu no modo 'Play', responsável por chamar o módulo de Jogo;
\end{itemize}

Jogador (player.c) - módulo responsável por criar/destruir um Jogador;
\begin{itemize}
\item void createPlayer(Player * player, char * name) - Construtor de jogador;
\item void deletePlayer(Player * player) - Destrutor de jogador;
\end{itemize}

Interrupções (ints.c) - contém as funções de instalação/desinstalação de interrupções escritas na linguagem Assembly ou C e função de habilitar/desabilitar de PICs;
\begin{itemize}
\item int install\_asm\_irq\_handler(int irq, void (*irq\_func)(void), \_go32\_dpmi\_seginfo * old\_irq) - instala a função irq\_func, escrita em Assembly, como o handler das interrupções associado à interrupção irq, actualizando a estrutura old\_irq com o handler de interrupções actual;
\item int install\_c\_irq\_handler(int irq, void (*irq\_func)(void), \_go32\_dpmi\_seginfo * old\_irq) - instala a função irq\_func, escrita em C, como o handler das interrupções associado à interrupção irq, actualizando a estrutura old\_irq com o handler de interrupções actual;
\item void reinstall\_asm\_irq\_handler(int irq, \_go32\_dpmi\_seginfo * old\_irq) - reinstala o handler das interrupções especificado em old\_irq para interrupções irq;
\item void reinstall\_c\_irq\_handler(int irq, \_go32\_dpmi\_seginfo * old\_irq) - reinstala o handler das interrupções especificado em old\_irq para interrupções irq;
\item void enable\_irq(int irq) - habilita a interrupção IRQ;
\item int disable\_irq(int irq) - desabilita a interrupção IRQ;
\item void disable\_int() - desabilita as interrupções globais;
\item void enable\_int() - habilita as interrupções globais;
\end{itemize}

Mouse - contém as funções para desenho do e de verificação para efectuar clique em opções do menu;
\begin{itemize}
\item int evaluateMouse(Menu * menu) - verifica se foi feito um clique no rato sobre uma opção do menu e actualiza opção seleccionada;
\item Bool insideOption(int x, int y, Option * op) - verifica se o rato esta sobre uma opção do menu;
\item void drawMouse(int * back, char * video\_base) - função que desenha o rato no ecrã;
\item void saveStat(int x, int y, int * backup, char * video\_base) - guarda o estado do rato, a cor dos pixeis onde o rato vai ser desenhado;
\item void parse\_mouse\_event(uchar * mouse) - processa o evento do rato, actualiza as variáveis estáticas x\_pos, y\_pos;
\end{itemize}

Real Time Controller (RTC) (rtc.c) - contém todas as funções necessárias à utilização do RTC. Inclui funções de escrita/leitura do RTC;
\begin{itemize}
\item Byte bcd2dec(Byte i) - converte BCD (Binary Coded Decimal) para decimal;
\item Byte dec2bcd(Byte i) - converte decimal para BCD(Binary Coded Decimal);
\item void rtc\_valid() - espera enquanto os dados rtc são válidos. Dados são válidos até +/- 240 usec depois da função retornar, o ler/escrever pode ser feito para o RTC neste periodo;
\item Byte read\_rtc(Byte add) - retorna os dados do endereço I/O do RTC, não valida bit;
\item Byte read\_rtcv(Byte add) - retorna os dados do endereço I/O do RTC, valida bit;
\item void write\_rtc(Byte add, Byte value) - escreve o valor add para I/O, não valida bit;
\item void write\_rtcv(Byte add, Byte value) - escreve o valor add para I/O, valida bit;
\item void rtc\_read\_time(RTC\_TIME *) - lê o tempo RTC;
\item void rtc\_read\_date(RTC\_DATE *) - lê a data RTC;
\item void rtc\_read\_alarm(RTC\_TIME *) - lê o alarme RTC;
\item void rtc\_write\_alarm(RTC\_TIME *) - escreve alarme para o RTC;
\end{itemize}

Controlador de Rato e Teclado (kbc.c) - contém as funções que activam/desactivam as interrupções provenientes do teclado e do rato e de controlo da actualização das coordenadas do rato;
\begin{itemize}
\item int read\_kbc(void) - retorna o data read do registo data, espera por OBF no registo do estado KBC\_TIMEOUT milisegundos então lê e retorna o data read do registo data. Retorna -1 quando timeout ou erro de transmissão;
\item int write\_kbc(unsigned ard, unsigned data) - escreve data no endereço IO adr, retorna -1 quando acontece um erro ou timeout espera por IBF no registo de estado, então escreve data no adr retorna -1 quando acontece timeout;
\item void mouse\_disable(void) - desabilita o rato, enviando StreamDisable para o rato, depois desabilita a geracao de interrupcoes do rato no KBC, envia DisableMouse para o KBC e finalmente desabilita interrupcoes do rato no PIC2;
\item int write\_kbc\_cmd(unsigned data) - escreve 'data' no registo, retorna 0 se ocorreu sucesso ou -1 o numero de tentativas foi ultrapassado (timeout);
\item int write\_kbc\_cmd\_arg(unsigned data, unsigned arg) - escreve 'data' no registo, retorna 0 se ocorreu sucesso ou -1 o numero de tentativas foi ultrapassado (timeout);
\item int write\_kbc\_data(unsigned data) - escreve 'data' no registo data, retorna ACk, erro ou -1 quando tempo de tentativa (timeout) for atingido;
\item int write\_kbc\_data\_arg(unsigned data, unsigned arg) - escreve 'data' no registo data, retorna ACk, erro ou -1 quando tempo de tentativa (timeout) for atingido;
\item int write\_aux(unsigned cmd) - envia 'cmd' para o rato, se uma resposta for recebido pelo KBC, tenta 3 vezes escrever 'cmd', reenvia toda a sequencia;
\item int write\_aux\_arg(unsigned cmd, unsigned arg) - envia 'cmd' para o rato, se uma resposta for recebido pelo KBC, tenta 3 vezes escrever 'cmd', reenvia toda a sequencia;
\end{itemize}

Music (music.c) - contém as funções necessárias ao uso do speaker no programa, mais concretamente, ligar/desligar esse speaker e tocar notas/músicas;
\begin{itemize}
\item void speaker\_on() - liga o speaker;
\item void speaker\_off() - desliga o speaker;
\item void play\_note(Note * note) - reproduz uma nota;
\item void play\_song(Song * s) - reproduz uma música;
\end{itemize}

Timer (timer.c) - contém as funções que programar os timers(0, 1, 2);
\begin{itemize}
\item void timer\_init(int timer, int mode) - programa o timer 0, 1, 2 com um modo;
\item void timer\_load(int timer, int value) - carrega o timer 0, 1, 2 com um valor;
\item void mili\_sleep(int mili) - espera mili milisegundos;
\item void sec\_sleep(int secs) - espera secs segundos;
\end{itemize}

Video (video-graphics.c) - contém as funções necessárias ao uso da placa gráfica do computador em modo gráfico. Inclui as funções de entrada/saída do modo gráfico, de desenho e obtenção de propriedades de pixéis, impressão de caracteres no ecrã e função que limpa o ecrã com uma determinada cor na sua totalidade;
\begin{itemize}
\item char * enter\_graphics(int mode, \_\_dpmi\_meminfo * map) - mapeia memória para a placa gráfica, entra em modo gráfico e inicializa as variáveis de resolução do ecrã;
\item void leave\_graphics(\_\_dpmi\_meminfo map) - desmapear a memória de video, desactivar apontadores e retornar ao modo texto;
\item void set\_pixel(int x, int y, int color, char * base) - desenha um pixel com uma determinada cor no ecrã, nas coordenadas (x,y);
\item int get\_pixel(int x, int y, char * base) - devolve a cor do pixel que está na posição (x,y);
\item void clear\_screen(int color, char * base) - pinta o ecrã de uma determinada cor, dando o efeito de se ter limpo o ecrã;
\item void draw\_line(int xi, int yi, int xf, int yf, int color, char * base) - desenha uma linha com uma cor entre as posições (xi, yi) e (xf, yf);
\item void drawCharAt(char c, int x, int y, int fore\_color, int back\_color, int char\_scale, char * video\_base, char * table) - desenha uma cadeia de caracteres na posição (x,y);
\item void drawIntAt(int num, int x, int y, int fore\_color, int back\_color, int char\_scale, char * video\_base, char * table) - desenha um número inteiro na posição (x, y);
\item void draw\_circle(int x0, int y0, int radius, int color, char * base) - função que desenha uma circunferência numa determinada posição (posição dada é o centro);
\item void drawTitle(char * title, int xi, int yi, int xf, int yf, int fore\_color, int back\_color, char * base, int char\_scale, char * table) - função que desenha um título numa determinada posição;
\item void drawBox(int xi, int yi, int xf, int yf, int fore\_color, int fill, char * base, char * table) - função que desenha uma caixa numa determinada posição;
\item void drawSpriteTitle(int x, int y, char * base) - função que desenha o título carregado duma sprite;
\end{itemize}

Sprite (sprite.c) - contém funções para ler ficheiro xpm, criar e desenhar sprite.
\begin{itemize}
\item char * read\_xpm(char * map[], int * wd, int * ht) - lê ficheiro xmp;
\item Sprite * create\_sprite(char * pic[], char * base) - função que cria sprite;
\item void delete\_sprite(Sprite * sprt, char * base) - função que apaga sprite;
\item void destroy\_sprite(Sprite * sprt, char * base) - função que destroi sprite;
\item void draw\_sprite(Sprite * sprt, char * base) - função de desenha sprite;
\end{itemize}

Embed (embed.c) - assim como o módulo Video, contém as funções necessárias ao uso da placa gráfica do computador em modo gráfico, com as devidas alterações para se poder usar estas em ambiente embebido;
\begin{itemize}
\item void mask\_pic(int irq) - mascara o bit correspondente a irq, desabilitando as suas interrupções;
\item void unmask\_pic(int irq) - desmascara o bit correspondente a irq, habilitando as suas interrupções;
\item void set\_pixel(int x, int y, int color, char * base) - desenha um pixel com uma determinada cor no ecrã, nas coordenadas (x,y);
\item int get\_pixel(int x, int y, char * base) - devolve a cor do pixel que está na posição (x,y);
\item void clear\_screen(int color, char * base) - pinta o ecrã de uma determinada cor, dando o efeito de se ter limpo o ecrã;
\item void draw\_line(int xi, int yi, int xf, int yf, int color, char * base) - desenha uma linha com uma cor entre as posições (xi, yi) e (xf, yf);
\item void drawCharAt(char c, int x, int y, int fore\_color, int back\_color, int char\_scale, char * video\_base, char * table) - desenha uma cadeia de caracteres na posição (x,y);
\item void drawIntAt(int num, int x, int y, int fore\_color, int back\_color, int char\_scale, char * video\_base, char * table) - desenha um número inteiro na posição (x, y);
\item void draw\_circle(int x0, int y0, int radius, int color, char * base) - função que desenha uma circunferência numa determinada posição (posição dada é o centro);
\item void drawTitle(char * title, int xi, int yi, int xf, int yf, int fore\_color, int back\_color, char * base, int char\_scale, char * table) - função que desenha um título numa determinada posição;
\item void drawBox(int xi, int yi, int xf, int yf, int fore\_color, int fill, char * base, char * table) - função que desenha uma caixa numa determinada posição;
\end{itemize}

Porta Série (serial.c) - contém as funções necessárias ao uso da comunicação em série entre dois PCs. Inclui as funções de inicializar/limpar a UART, definição/obtenção dos registos da UART e que permitem enviar/receber caracteres ou strings enviadas/recebidas pela UART;
\begin{itemize}
\item Byte get\_uart\_register(Word base, Word reg) - função que retorna os registos da UART;
\item void set\_uart\_register(Word base, Word reg, Byte b) - função que define os registos da UART;
\item int get\_baud(Word base) - função que devolve a baudrate;
\item void set\_baud(Word base, int rate) - função que define a baudrate;
\item Byte get\_parity(Word base) - função que devolve os bits de paridade;
\item void set\_parity(Word base, Byte par) - função que define os bits de paridade;
\item int get\_nbits(Word base) - função que devolve os n bits;
\item void set\_nbits(Word base, int nbits) - função que define os n bits;
\item int get\_stop\_bits(Word base) - função que devolve os stop bits;
\item void set\_stop\_bits(Word base, int stop) - função que define os stop bits;
\item void init\_uart(Word base, int rate, int nbits, int stop\_bits, Byte parity, Bool rx\_int\_enable, Bool tx\_int\_enable, Bool fifo\_enable) - função que inicializa a UART;
\item void send\_char(Word base, char c) - função que envia um caracter de um porto de série para o outro;
\item char rcv\_char(Word base) - função que recebe um caracter do outro porto de série;
\item void send\_string(Word base, char * string) - função que envia uma string de um porto de série para o outro;
\item char * rcv\_string(Word base) - função que recebe uma string do outro porto de série;
\item Bool char\_available(Word base) - função que indica que é possível ler o caracter recebido;
\item void sync\_lock(Word base) - função que bloqueia a sincronização entre os dois jogadores;
\item void sync\_unlock(Word base) - função que desbloqueia a sincronização entre os dois jogadores;
\item void cleanUART(Word base) - função que limpa a UART
\end{itemize}

\chapter{Diagrama de Chamada de Funções}
\begin{figure}[ht]
\begin{center}
\includegraphics[width=10cm]{./sync.png}
\end{center}
\caption[Chamada de funções do sync\_client]{Chamada de funções do sync\_client}
\end{figure}
\begin{figure}[ht]
\begin{center}
\includegraphics[width=8cm]{./playsingle.png}
\end{center}
\caption[Chamada de funções do playsingle]{Chamada de funções do main}
\end{figure}
\newpage
\begin{figure}[ht]
\begin{center}
\includegraphics[width=11cm]{./main.png}
\end{center}
\caption[Chamada de funções do main]{Chamada de funções do main}
\end{figure}
\chapter{Histórico do desenvolvimento}
\chaptermark{Appendix}
\markboth{Appendix}{Appendix}
{\noindent\hsize8cm\lstinputlisting{./svn_log}}
\chapter{Makefile}
{\noindent\hsize8cm\lstinputlisting{../src/makefile}}
\chapter{Proposta inicial}
\chaptermark{Appendix}
\markboth{Appendix}{Appendix}


Nomes: Ângela Igreja (ei08164) e Ricardo Silva (ei08121)\\[0.25cm]
Turma: 2MIEIC1\newline
Grupo: 2MIEIC1 - 5\newline
Data: 29/04/10]\newline
Título: O Enforcado\newline
Tipo: Jogo Clássico\newline
Baseado em: Jogo Tradicional d’ “O Enforcado”\\[0.15cm]
Periféricos: Placa gráfica no modo texto, gráfico, contador, altifalante, teclado, RTC e Porto Série, Rato.\\[0.15cm]
Interrupções: contador, teclado/rato, RTC.\\[0.15cm]


Descrição:


	O “O Enforcado” é um jogo para dois jogadores (caso não haja um segundo jogador, o jogo também tem um dicionário com palavras) que tem como objectivo um jogador adivinhar a palavra do outro, podendo errar na letra até 6 vezes. 

	O primeiro jogador escreve qual a palavra-chave e uma dica para ajudar o outro jogador a chegar à palavra. O segundo jogador recebe a dica e os respectivos espaços para inserir a palavra-chave. Insere uma letra. Se esta estiver na palavra, é lhe mostrada no respectivo espaço. Se não pertencer à 
palavra, uma parte do enforcado é desenhada. Se inserir uma letra que já tenha sido usada, um bip e uma mensagem de erro são lhe mostradas. 

	Se o segundo jogador adivinhar a palavra antes de o enforcado ser todo desenhado, o jogo termina com sucesso e é atribuída uma pontuação, pontuação esta que será conforme o tamanho da palavra e do número de vezes que errou. Caso ele não chegue a adivinhar a palavra antes do enforcado ser todo desenhado, o jogo termina com insucesso.

	A interface usa a placa gráfica no modo gráfico para desenhar os espaços e o enforcado. Os jogadores interagem com a aplicação através do rato ou teclado, podendo optar por escolher, no menu, se desejam jogar ou consultar as pontuações).
	
	
Planeamento:


1ª Semana (Data de Conclusão: 29/04/10):
\begin{itemize}

\item Criar uma disquete de arranque com um bootloader que, após o arranque do PC, pretende executar o programa em modo texto;

\item Iniciar Timer0, escrever isr e mostrar, no modo gráfico usando drawIntAt() o valor da variável  global que marca o tempo;

\item Criar interface básica do Jogo em Modo texto (Menu Principal do Programa);

        void initMenu( char options[][24]  , Menu * menu , int num-options);

        void printMenu( Menu * menu );

        Bool updateMenu( int sc , Menu * menu );

        int selectedOption(Menu * menu);

        void sub-menu( Menu * menu );

\item Utilizar interrupções do teclado e definir módulo para identificar scancodes e associar a teclas ou a caracteres ASCII relevantes;

\end{itemize}

2ª/3ª Semana (Data de Conclusão: 8/05/10):
\begin{itemize}

\item Criar o motor principal do Jogo:

        Modo 1 jogador:

            Criar um função que gere uma palavra e uma dica aleatoriamente;

                Word * generate-string( Word ** dictionary );

        Modo 2 jogadores: 

            Criar uma comunicação através de porta série entre dois computadores;

            Criar modo 2 jogadores num computador;

\item Criar função que verifica se a letra está na palavra; 

   	    Bool  find-letter (char * word  , char letter ) 

\item Criar interface da opção Jogar em modo gráfico; 

\item Criar função que coloca a(s) letra(s) correcta(s) nos lugares correspondentes da palavra;

        void update-word (char * word , char letter) 

\item Criar função que desenha os traços de acordo com o número de letras da palavra; 

        void draw-traces(int x-pos, int y-pos , int color, char *base, char * word)

\item Criar função para criar um círculo, para desenhar a cabeça do enforcado  

        void draw-circle(int xcenter, int ycenter, int radius, int color, char* base); 

\item Criar função que desenha a forca;

        void draw-gallow (int x-pos, int y-pos , int color, char *base);

\item Criar função que desenha o enforcado de acordo com o número de erros;

        void draw-Hangman ( int x-pos , int y-pos, int color, char * base , int num-errors);

\item Criar função que calcula a Pontuação obtida por um jogador que adivinhou a palavra;

        int calculate-score(int num-errors, int num-letters);

\item Criar função que devolve os jogadores que tem as melhores pontuações;

        Player ** get-best-scores ( Player ** best-players , int num); 

\item Criar função que mostra no ecrã as melhores Pontuações;

        void print-best-scores(Players ** best-players);

\item Criar função que actualiza as Pontuações Máximas; 

	    void update-best-scores(Players ** best-players , Player* player)

\item Colocar programa a efectuar um beep quando o utilizador errar na letra e a tocar uma melodia quando ganhar o jogo;

\end{itemize}

4ª Semana (Data de Conclusão: 15/05/10):
\begin{itemize}

\item Criar função que mostra o manual de instruções;

      void  show-manual();

\item Implementar a utilização do rato na interface gráfica num botão para ver as Pontuações do Jogo;

\end{itemize}


\end{document}
